Method and system for byzantine fault-tolerance replicating of data

ABSTRACT

A method for byzantine fault-tolerance replicating of data on a plurality of n servers includes performing a preprocessing procedure. The n servers include one primary node (PN) and n−1 backup nodes (BN), wherein f servers may arbitrarily fail, and wherein all n servers have a trusted computing entity (TCE). The preprocessing procedure is performed by the TCE of the PN and includes computing a random secret value for a unique, monotonic, sequential counter (UMSC) to be assigned with a request message for requesting an operation to be performed, computing a commitment for the random secret value and the UMSC, and splitting the random secret value into a plurality of shares. The preprocessing procedure further includes computing a server-specific authenticated encryption of each share, and providing the computed server-specific shares and the computed commitment to the respective servers.

CROSS REFERENCE TO RELATED APPLICATIONS

This application is a continuation of U.S. patent application Ser. No. 16/081,429, filed on Aug. 31, 2018, which is a U.S. National Stage Application under 35 U.S.C. § 371 of International Application No. PCT/EP2016/078883, filed on Nov. 25, 2016, both of which are hereby incorporated by reference herein. The International Application was published in English on May 31, 2018 as WO 2018/095540 A1 under PCT Article 21(2).

FIELD

The present invention relates to a method for byzantine fault-tolerance replicating of data on a plurality of n servers by a client, said n servers comprising one primary node, ‘PN’, and n−1 backup nodes, ‘BN’, wherein f servers may arbitrarily fail and wherein all n servers having a trusted computing entity, ‘TCE’.

The present invention further relates to a system byzantine fault-tolerance replicating of data on a plurality of n servers by a client, said n servers comprising one primary node, ‘PN’ and n−1 backup nodes, ‘BN’, wherein f servers may arbitrarily fail, and wherein all n servers having a trusted computing entity, ‘TCE’.

The present invention further relates to a non-transitory computer readable medium storing a program causing a computer to execute a method for byzantine fault-tolerance replicating of data on a plurality of n servers by a client, said n servers comprising one primary node, ‘PN’ and n−1 backup nodes, ‘BN’, wherein f servers may arbitrarily fail, and wherein all n servers having a trusted computing entity, ‘TCE’.

BACKGROUND

A so-called byzantine fault was introduced to capture arbitrary behavior of a faulty process e.g. as disclosed in the non-patent-literature of L. Lamport, R. Shostak, and M. Pease, “The byzantine generals problem,” ACM Trans. Program. Lang. Syst., vol. 4, no. 3, pp. 382-401, July 1982. For instance, an adversary can control the behavior of the compromised processes in order to cause the rest of the system to act in an erroneous way. Asynchrony is a non-assumption about timing properties, i.e., there is no assumption about the processing speeds and transmission delays. This (non-) assumption is realistic when the adversary fully controls the network: Attackers can often violate some timing properties by launching denial-of-service attacks against processes or communications. For instance, the attacker might delay the communication of a process for an interval, breaking some assumption about the timeliness of the system.

This system model—Byzantine faults and asynchrony—leads to an impossibility result, which says that consensus can not be deterministically solved in an asynchronous system if a single process can crash (often called the Fischer-Lynch-Paterson, FLP, result as described in the non-patent literature of T. C. Group, “Tpm main, part 1 design principles. specification version 1.2, revision 103.” 2007. The reason for the impossibility is that in an asynchronous system it is impossible to differentiate a crashed process from another that is simply slow or connected by a slow network link.

With the widespread deployment of cryptocurrencies like Bitcoin, one of their supporting technologies, blockchain, becomes increasingly popular. It is a distributed consensus protocol that serves as a public ledger for cryptocurrency transactions. One of the problems is that their consensus protocols provide only probabilistic consistency guarantees.

In order to build a distributed consensus systems that provide strong consistency guarantees, financial institutions have begun to investigate the traditional Byzantine fault tolerant (BFT) protocols, which enable n servers to collectively act as a single machine even if f of them misbehave or malfunction in arbitrary (“Byzantine”) ways. However, practitioners usually hesitate to deploy such BFT protocols because of two reasons. The first reason is their poor scalability in terms of number of servers due to their intensive network communication which often involves as many as O(n²) messages for each request as for example disclosed in the non-patent literature of B.-G. Chun, P. Maniatis, S. Shenker, and J. Kubiatowicz, “Attested append only memory: Making adversaries stick to their word,” in Proceedings of Twenty-first ACM SIGOPS Symposium on Operating Systems Principles, ser. SOSP '07. New York, N.Y., USA: ACM, 2007, pp. 189-204, available online: http://doi.acm.org/10.1145/1294261.1294280. The second reason is their high resource consumption, which requires n≥3f+1 servers to tolerate up to f faults as for example disclosed in the non-patent literature of M. Castro and B. Liskov, “Practical byzantine fault tolerance,” in Proceedings of the Third Symposium on Operating Systems Design and Implementation, ser. OSDI '99. Berkeley, Calif., USA: USENIX Association, 1999, pp. 173-186, available online http://dLacm.org/citation.cfm?id=296806.296824.

Another conventional BFT-protocol called practical Byzantine fault tolerance (PBFT) for state machine replication services is shown in the non-patent literature of B.-G. Chun, P. Maniatis, S. Shenker, and J. Kubiatowicz, “Attested append only memory: Making adversaries stick to their word,” in Proceedings of Twenty-first ACM SIGOPS Symposium on Operating Systems Principles, ser. SOSP '07. New York, N.Y., USA: ACM, 2007, pp. 189-204, available online: http://doi.acm.org/1 0.1 145/1294261. 1294280. Such a service is modeled as a state machine that is replicated across different servers in a distributed system. Each server maintains the service state and implements the service operations. Clients send requests to execute operations to the servers and PBFT ensures that all non-faulty servers execute the same operations in the same order.

Recently, trusted hardware has become widely available on commodity computing platforms. Trusted execution environments (TEES) are already pervasive on mobile platforms, as e.g. disclosed in the non-patent-literature of J. Ekberg, K. Kostiainen, and N. Asokan, “The untapped potential of trusted execution environments on mobile devices,” IEEE Security & Privacy, vol. 12, no. 4, pp. 29-37, 2014, and newer TEEs e.g. disclosed in the non-patent-literature of F. McKeen, I. Alexandrovich, A. Berenzon, C. V. Rozas, H. Shafi, V. Shanbhogue, and U. R. Savagaonkar, “Innovative instructions and software model for isolated execution,” in HASP, 2013, pp. 10:1-10:1 or Intel, “Software Guard Extensions Programming Reference,” 2013 are being deployed on PCs and servers. A TEE provides confidentiality and integrity protection for the data inside its memory, and ensures that no one can interfere with its operation.

Trusted hardware has also been used to reduce the number of servers and/or communication phases for BFT protocols e.g. disclosed in the non-patent-literature of:

-   M. Correia, N. F. Neves, and P. Verissimo, “How to tolerate half     less one byzantine nodes in practical distributed systems,” in     Reliable Distributed Systems, 2004. Proceedings of the 23rd IEEE     International Symposium on, October 2004, pp. 174-183, -   G. S. Veronese, M. Correia, A. N. Bessani, L. C. Lung, and P.     Verissimo, “Efficient byzantine fault-tolerance,” IEEE Transactions     on Computers, vol. 62, no. 1, pp. 16-30, January 2013, -   G. S. Veronese, M. Correia, A. N. Bessani, and L. C. Lung, “Ebawa:     Efficient byzantine agreement for wide-area networks,” in High     Assurance Systems Engineering (HASE), 2010 IEEE 12^(th)     International Symposium on, November 2010, pp. 10-19, -   R. Kapitza, J. Behl, C. Cachin, T. Distler, S. Kuhnle, S. V.     Mohammadi, W. Schroder-Preikschat, and K. Stengel, “Cheapbft:     Resource-efficient byzantine fault tolerance,” in Proceedings of the     7^(th) ACM European Conference on Computer Systems, ser. EuroSys     '12. New York, N.Y., USA: ACM, 2012, pp. 295-308, -   B.-G. Chun, P. Maniatis, S. Shenker, and J. Kubiatowicz, “Attested     append-only memory: Making adversaries stick to their word,” in     Proceedings of Twenty-first ACM SIGOPS Symposium on Operating     Systems Principles, ser. SOSP '07. New York, N.Y., USA: ACM, 2007,     pp. 189-204, and -   D. Levin, J. R. Douceur, J. R. Lorch, and T. Moscibroda, “Trinc:     Small trusted hardware for large distributed systems,” in     Proceedings of the 6th USENIX Symposium on Networked Systems Design     and Implementation, ser. NSDI'09. Berkeley, Calif., USA: USENIX     Association, 2009, pp. 1-14.

For example, MinBFT, e.g. disclosed in the non-patent-literature of G. S. Veronese, M. Correia, A. N. Bessani, L. C. Lung, and P. Verissimo, “Efficient byzantine fault-tolerance,” IEEE Transactions on Computers, vol. 62, no. 1, pp. 16-30, January 2013 uses a trusted monotonic counter to build a Unique Sequential Identifier Generator (USIG) service to prevent a faulty server from making conflicting statements, which is called equivocation. As a result, the number of required servers is reduced from 3f+1 to 2f+1 and the number of communication phases is reduced from 3 to 2. In more detail a trusted monotonic counter is used to build a Unique Sequential Identifier Generator (USIG), which is a local service that exists in every server. It assigns each requested message M a unique identifier (UI), which is a cryptographic signature of M together with a unique, monotonic and sequential counter c. These three properties imply that the USIG (1) will never assign the same identifier to two different messages (uniqueness), (2) will never assign an identifier that is lower than a previous one (monotonicity), and (3) will never assign an identifier that is not the successor of the previous one (sequentiality). These properties are guaranteed even if the server is compromised, and the service is implemented inside a trusted execution environment.

For instance CheapBFT as e.g. disclosed in the non-patent-literature of R. Kapitza, J. Behl, C. Cachin, T. Distler, S. Kuhnle, S. V. Mohammadi, W. Schroder-Preikschat, and K. Stengel, “Cheapbft: Resource-efficient byzantine fault tolerance,” in Proceedings of the 7^(th) ACM European Conference on Computer Systems, ser. EuroSys '12. New York, N.Y., USA: ACM, 2012, pp. 295-308 further improves the performance by running a composite agreement protocol. In the absence of faults, it requires that only f+1 servers actively agree on and execute client requests. The other f passive servers just modify their states by processing state updates provided by the active servers. In case of suspected faulty behavior, CheapBFT triggers a transition protocol to activate the passive servers, and then switch to MinBFT.

However, MinBFT uses a Trusted Platform Module (TPM) e.g. as disclosed in the non-patent-literature of T. C. Group, “Tpm main, part 1 design principles. specification version 1.2, revision 103” 2007, which limits the rate for counter generation, and CheapBFT uses FPGA-based trusted subsystem. Furthermore, both MinBFT and CheapBFT require each (active) server to do multicast or even all-to-all broadcast, which leads to a communication/message complexity of O(n²).

In the non-patent literature of E. Syta, I. Tamas, D. Visher, D. I. Wolinsky, L. Gasser, N. Gailly, and B. Ford, “Keeping authorities “honest or bust” with decentralized witness cosigning,” in 37th IEEE Symposium on Security and Privacy, 2016] a multisignature procedure is shown allowing an aggregation of messages. However a disadvantage is that the shown multisignature procedure leads to larger messages sizes and longer processing times. A further disadvantage is that replicas have to sign different messages.

SUMMARY

In an embodiment, the present invention provides a method for byzantine fault-tolerance replicating of data on a plurality of n servers. Then servers comprise one primary node (PN) and n−1 backup nodes (BN), wherein f servers may arbitrarily fail, and wherein all n servers have a trusted computing entity (TCE). The method comprises performing, by the TCE of the PN, a preprocessing procedure. The preprocessing procedure comprises the steps of computing at least one random secret value for at least one respective counter value of a unique, monotonic, sequential counter (UMSC) to be assigned with a request message for requesting an operation to be performed, computing a commitment for the random secret and the UMSC, and splitting the at least one random secret into a plurality of shares. The preprocessing procedure further comprises computing a server-specific authenticated encryption of each share of the at least one random secret, such that decryption can only be performed by the specified respective server, wherein during a later procedure the server-specific shares are used for verifying the request message, and providing the computed server-specific shares and the computed commitment to the respective servers.

BRIEF DESCRIPTION OF THE DRAWINGS

The present invention will be described in even greater detail below based on the exemplary figures. The invention is not limited to the exemplary embodiments. All features described and/or illustrated herein can be used alone or combined in different combinations in embodiments of the invention. The features and advantages of various embodiments of the present invention will become apparent by reading the following detailed description with reference to the attached drawings which illustrate the following:

FIG. 1 shows a system according to an embodiment of the present invention;

FIG. 2 shows parts of steps of a method according to an embodiment of the present invention; and

FIG. 3 shows parts of steps of a method according to a further embodiment of the present invention.

DETAILED DESCRIPTION

At least one embodiment of the present invention provides for increasing the performance of byzantine fault-tolerance replication of data by lowering the computational resources like memory and CPU cycles while at least not significantly increasing the number and size of network packets. At least one embodiment of the present invention therefore provides for reducing the number of operations of replicas on messages like signing, etc.

In an embodiment, the present invention provides a method for byzantine fault-tolerance replicating of data on a plurality of n servers, said n servers comprising one primary node, ‘PN’ and n−1 backup nodes, ‘BN’, wherein f servers may arbitrarily fail, and wherein all n servers having a trusted computing entity, ‘TCE’, comprising a preprocessing procedure performed by said TCE of said PN, said procedure comprising the steps of:

-   -   Computing a random secret value for a unique, monotonic,         sequential counter, ‘UMSC’, to be assigned with a request         message for requesting an operation to be performed,     -   Computing a commitment for said random secret value and said         UMSC,     -   Splitting said random secret value into a plurality of shares,     -   Computing a server-specific authenticated encryption of each         share, such that decryption can only be performed by said         specified respective server, wherein during a later procedure         the server-specific shares are used for verifying said request         message.     -   Providing said computed server-specific shares and said computed         commitment to the respective servers.

In a further embodiment the present invention provides a system for byzantine fault-tolerance replicating of data on a plurality of n servers by a client, said n servers comprising one primary node, ‘PN’ and n−1 backup nodes, ‘BN’, wherein f servers may arbitrarily fail, and wherein all n servers having a trusted computing entity, ‘TCE’, Said TCE of said PN being adapted to perform the steps of:

-   -   Computing a random secret value for a unique, monotonic,         sequential counter, ‘UMSC’, to be assigned with a request         message for requesting an operation to be performed,     -   Computing a commitment for said random secret value and said         UMSC,     -   Splitting said random secret value into a plurality of shares,     -   Computing a server-specific authenticated encryption of each         share, such that decryption can only be performed by said         specified respective server, wherein during a later procedure         the server-specific shares are used for verifying said request         message.     -   Providing said computed server-specific shares and said computed         commitment to the respective servers.

In a further embodiment the present invention provides a non-transitory computer readable medium storing a program causing a computer to execute a method for byzantine fault-tolerance replicating of data on a plurality of n servers, said n servers comprising one primary node, ‘PN’ and n−1 backup nodes, ‘BN’, wherein f servers may arbitrarily fail, and wherein all n servers having a trusted computing entity, ‘TCE’, comprising a preprocessing procedure performed by said TCE of said PN, said procedure comprising the steps of:

-   -   Computing a random secret value for a unique, monotonic,         sequential counter, ‘UMSC’, to be assigned with a request         message for requesting an operation to be performed,     -   Computing a commitment for said random secret value and said         UMSC,     -   Splitting said random secret value into a plurality of shares,     -   Computing a server-specific authenticated encryption of each         share, such that decryption can only be performed by said         specified respective server, wherein during a later procedure         the server-specific shares are used for verifying said request         message.     -   Providing said computed server-specific shares and said computed         commitment to the respective servers.

At least one embodiment of the present invention may have the advantage of reducing the computation time and resources of counter-based protocols using secret sharing to minimize or completely eliminate public key operations resulting in a much lower computation time and resources.

At least one embodiment of the present invention may have the advantage of aggregating messages, so that replicas do not have to perform extensive e.g. all-to-all broadcasting of messages.

At least one embodiment of the present invention may have the advantage of receiving only one message, e.g. by a client instead of f+1 messages for a request.

At least one embodiment of the present invention may have the advantage that all replicas maintain the same counter value.

Notation Description Entities C Client S Server S_(p) Primary S_(i) Backup USIG Unique Sequential Identifier Generator Objects M Request message UI Unique Identifier N Ephemeral nonce Parameters n Number of servers f Number of faulty servers p Primary number v View number c Counter value Cryptographic Notations H( ) Cryptographic hash function h Cryptographic hash E( ) Authenticated encryption σ Signature

The term “computer readable medium” may refer to any kind of medium, which can be used together with a computation device or computer and on which information can be stored. Said information may be any kind of data which can be read into a memory of a computer. For example said information may include program code for executing with said computer. Examples of a computer readable medium are tapes, CD-ROMs, DVD-ROMs, DVD-RAMs, DVD-RWs, BluRay, DAT, MiniDisk, solid state disks SSD, floppy disks, SD-cards, CF-cards, memory-sticks, USB-sticks, EPROM, EEPROM or the like.

The terms “client”, “server”, “primary node”, and “backup node” each refer in particular in the claims, preferably in the description each to an entity, device or computing device adapted to perform computing like a personal computer, a tablet, a mobile phone, a server, or the like and comprises one or more processors having one or more cores and may be connectable to a memory for storing an application which is adapted to perform corresponding steps of one or more of the embodiments of the present invention. Any application may be software based and/or hardware based installed in the memory on which the processor(s) can work on. The entities may be adapted in such a way that the corresponding steps to be computed are performed in an optimized way. For instance different steps may be performed in parallel with a single processor on different of its cores. Further a plurality of same or different entities may be identical forming a single computing entity. The entity or entities may also be instantiated as a virtual entity running on a single or a plurality of physical computing resources. Different entities may therefore be executed on said physical computing resource.

The term “trusted computing entity” or “TCE” refers in particular in the claims, preferably in the specification to an entity, device or computing device isolating and protecting security-critical logic from all other hardware and software running on an entity or server. A trusting computing entity provides confidentiality and integrity protection for a trusted application running within a trusted execution environment respectively on said trusting computing entity, ensuring that no application running outside said trusted execution environment can interfere with the trusted application's operation. The trusted execution environment provided or spanned by a trusted computing entity may provide some form of remote attestation allowing remote users to certain the current configuration and behavior of a trusted application. The trusted execution environment may be provided in form of a central processing unit or the like.

The term “multicasting” refers in particular in the claims, preferably in the specification to a group communication where information is addressed to a group of destination devices simultaneously. Multicast is also known as a one-to-many or many-to-many communication.

The term “unique, monotonic and sequential counter” with regard to a message refers in particular in the claims, preferably in the specification to an information, data or message to which a counter is assigned which is never the same for two different information (uniqueness), which is lower than a previous one (monotonicity) and which is not the successor of the previous one (sequentiality).

The terms “star topology”, “tree topology” and “tree” respectively are to be understood in their respective broadest sense and each refer particular in the claims, preferably in the specification to a connection topology between servers which may be physically and/or virtually organized as a star or a tree respectively. In a star topology an entity or device forming the center of the star is physically and/or virtually connected directly to each of the other entities or devices in this topology. In a tree topology one of the entities or devices performing the network is a root of the tree which is connected to one or more children, wherein said children—now parents—may be again connected to one or more other children and so on.

The term “spanning tree” is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to the spanning tree protocol STP according to IEEE 802.1D.

The term “aggregated” with regard to the term “signature” or “share” refers in particular in the claims, preferably in the specification to a signature, share or secret generated by using signature parts, shares or parts of a secret, said signature parts or secret parts being generated by different entities or devices and being collected before, to compute a single aggregated signature or single aggregated secret.

The term “view” is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to a certain network configuration. For example in a view one server is the primary server PN and the other servers are backup servers. For instance PN picks the ordering for execution of operations requested by clients C. For instance it does this by assigning the next available sequence number to a request and sending this assignment to the backups. But PN may be faulty: it may assign the same sequence number to different requests, stop assigning sequence numbers, or leave gaps between sequence numbers. Therefore the backups may check the sequence numbers assigned by the PN and use timeouts to detect when it stops. They may trigger view changes to select a new PN when it appears that the current one has failed.

The term “server-specific share” or “BN-specific share” respectively is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to a share being calculated via an authenticated encryption such that it can only be decrypted by the corresponding server or node.

The term “commitment” is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to a scheme allowing one to commit to a chosen value or statement while keeping it hidden to others, with the ability to reveal the committed value or statement later.

The terms “validating” and “verifying” are to be understood in their broadest sense and refer in particular in the claims, preferably in the specification each to a procedure performing reviewing, investigating, (re)checking, controlling, confirming, (re)assuring, attesting, affirming, certifying, etc.

The term “integrity” with respect to any kind of data, information, message, share or the like is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to the completeness, intactness, inviolacy, inviolability, etc. of said data, information, message, share or the like.

The term “collecting” with respect to any kind of data, information, message, share or the like is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to fetch, receive, obtain, get, request and receive said data, information, message, share or the like.

The term “reconstructing” with respect to any kind of data, information, message, share or the like is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to rebuild, rearrange, reconfigure, reconstruct, redesign, recompute, reassemble, etc. of said data, information, message, share or the like.

The term “active” with respect to the term “server” or “BN” this to be understood in its broadest sense, and refers in particular in the claims, preferably in the specification to servers executing requests, for example client requests, etc. whereas the term “passive” with respect to the term “server” or “BN” in turn means that said passive server only modifies its state, for instance by processing state updates provided by the active servers.

The term “distance parameter” is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to parameter indicating some kind of or sort of physical or virtual space, range, separation, distance, etc. between two computing entities being defined for example by a network topology, by a network administrator, and/or by network parameters like throughput, round-trip time, round-trip delay, etc.

The term “history information” may be understood in its broadest sense and refers in particular in the claims, preferably in the specification to information which may include but is not limited to prepare messages for the prepared requests, commit messages for the committed requests, reply messages for the executed requests and requests for the request that receive no pre-pass. In other words the term “history information” includes all prepared, committed and executed requests.

The term “matching” is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to a comparison, replication, adjustment, balance, checking for correctness, similarity, the quality, etc.

The term “direct” with regard to the term “connection” or “connecting” is to be understood in its broadest sense and refers in particular in the claims, preferably in the specification to any kind of connection without a detour, indirection, loop way physically and/or virtually.

Further features, advantages and further embodiments are described or may become apparent in the following:

Said PN may receive a request message for requesting a certain operation and said PN may computes a prepare message including at least the content of said request message and a unique identifier, ‘UI’, said UI being computed by said TCE of said PN, said UI being based on a cryptographic signature of said request message and said UMSC wherein said PN may provide said prepare message to said BN. This enables to assign said UMSC to said request message in said prepare message.

At least one of the steps of

-   -   ii. decrypting said BN-specific share by said BN and providing         the decrypted share to said PN,     -   iii. Collecting, by said PN, a number of shares,     -   iv. Reconstructing, by said PN, the secret value based on the         collected shares and/or the share of said PN,     -   v. Verifying, by said PN, the reconstructed secret by using it         to open said computed commitment during said preprocessing         procedure, wherein said PN may perform said request when said         reconstructed secret is verified,     -   vi. Transmitting said opened commitment to said BN, wherein said         opened commitment may be transmitted by broadcasting, and     -   vii. Comparing, by each of said BN, said received transmitted         opened commitment with the commitment received during said         preprocessing phase may be performed. This enables in an         efficient way to verify the request message.

Prior to step ii) a step i) validating, by each of said BN, said prepare message by checking the UI by each of the TCE of the respective BN, may be performed and wherein after step vii) a step viii) performing the request of said request message by said BN upon positive result of said comparison may be performed. This enables to validate said prepare message and to perform the request.

If the number of collected shares is smaller than the number of n servers, then the integrity of each collected share may be checked by said PN prior to reconstructing said secret value, wherein said number of shares may be equal to the number of servers. This avoids a complete reconstruction of the secret with corrupt shares, thus avoiding a waste of computational resources.

For authenticated encryption a public key of each BN may be used or a pair-wise symmetric encryption between the PN and each of said BN may be used. Using symmetric key encryption enables for example to eliminate public key operations.

Said PN may perform said request when said reconstructed secret is verified. This enables to perform the request immediately when a verified secret is available.

Active BN may be detected by said PN, and wherein only said determined active BN may be used for performing at least one step of the method. This enables by a central entity to determine active BN and to perform steps of the method only with determined active BN. Thus communication time and resources are further reduced and detection of BN being active is performed by a single entity.

Said active BN may be organized by said PN into a spanning tree comprising nodes and said tree being rooted at said PN, wherein communication is performed along said spanning tree of active BN aggregating shares by intermediate nodes within said tree. This improves the scalability.

Said PN may be selected out of all servers and wherein, when said PN is determined to be faulty, new PN out of active BN is selected. This enhances the efficiency since a faulty PN is replaced by a new BN of all servers now acting as PN.

A PN may be determined faulty by said client by not receiving a reply message after expiry of a certain time after having sent said request message. This enables in an easy way to determine a PN being faulty.

Said new PN may be selected by the steps of

-   -   a) Requesting a view change by a BN after expiry of said certain         time period for waiting for a response of a PN, by sending a         view change message to all other BN,     -   b) Choosing a new PN as a BN being active and being closest to         the old PN according to a distance parameter,     -   c) Computing a history message, by said new PN, comprising         information of the latest local counter value and request         history information about communication performed between said         new PN and said old PN and said new PN and other BN,     -   d) Sending said history message to all other BN by said new PN,     -   e) Computing a view change message by each of said BN, after         verifying the received request history information,     -   f) Providing said computed view change message to all other BN         after having verified the request history information of a         received history message,     -   g) Upon having received f matching view change messages, by a         BN, and having a verified request history, processing the         verified history,     -   h) Upon having received f matching view change messages by said         new PN, said new PN provides view change messages to said f BN         indicating that a new PN is established.

This enables in a fast and efficient way to perform a view change, i.e. to switch from a faulty PN to a new PN.

A faulty BN may be identified by the steps of

-   -   a) Upon at least one of sending and receiving, of a message,         starting a timer by a BN, associated with each directly         connected BN,     -   b) When not receiving a valid share from a directly connected BN         before expiry of the timer for said directly connected BN,         providing a suspect message at least to said PN indicating a         possible failure of said directly connected BN,     -   c) Upon receiving, by said PN, at least one suspect message,         determining said possibly faulty BN and selecting a replacement         BN for said determined faulty BN,     -   d) Providing information about said replacement BN to the other         BN, such that said determined faulty BN is ignored by the other         BN.

This enables the fast and efficient way to detect faulty BN.

Said directly connected BN may the children of said BN and wherein said suspect message may be also provided to the parent of said BN and wherein a suspect message may be provided along the tree to said PN. This passing along the tree enables to cancel timers and to reduce the number of suspect messages, that means communication is reduced.

A view number may be included into the messages for indicating a current view determining a certain server being PN and other servers being BN. This allows an easy way with minimum of data to determine a current configuration of PN and BN.

Upon valid verification of said reconstructed secret said PN may perform the request and wherein the result of the performed request may be transmitted to said BN together with an increased counter value.

There are several ways how to design and further develop the teaching of the present invention in an advantageous way. To this end it is to be referred to the patent claims subordinate to the independent claims on the one hand and to the following explanation of further embodiments of the invention by way of example, illustrated by the figure on the other hand. In connection with the explanation of the further embodiments of the invention by the aid of the figure, generally further embodiments and further developments of the teaching will be explained.

In FIG. 1 a state machine replication service 1 is shown having a primary node 2 which includes a rich execution environment REE for performing a byzantine free tolerance application and a TEE being a trusted execution environment on which a unique sequential identifier generator USIG is run. Further backup servers 3 are shown also running a byzantine free tolerance protocol performed in the state machine replication service. A client C requests executing a certain operation and sends a request to the primary 2 and all backup servers 3 which are shown in FIG. 2 in more detail.

FIG. 2 shows parts of steps of a method according to an embodiment of the present invention and FIG. 3 shows parts of steps of a method according to a further embodiment of the present invention.

The term S_(p) with reference sign 2, is interchangeably used for the primary node PN, the term S_(i) with reference sign 3 is interchangeably used for the i-th active BN in FIGS. 2 and 3 and reference sign 4 denotes passive BN/replica.

In FIG. 2 in the first step 1) a setup procedure by the primary node PN this performed according to the following:

-   -   The S_(p)'s local TEE sets up a secret key k_(i), with the         S_(i)'s local TEE of each BN/S_(i).     -   S_(p) organizes active S_(i)s into a spanning tree.

In a second step 2) the PN S_(p) performs a preprocessing procedure according to the following: For each counter value c^(j), S_(p)'s local TEE does the followings:

-   -   1) generates a random secret s^(j) and calculates h^(j)←H(s^(j),         c^(j));     -   2) splits s^(j) into s₁ ^(j)⊕ . . . ⊕s_(f+1) ^(j)     -   3) for each active S_(i), calculates C_(i) ^(j)=E(k_(i),         s_(i) ^(j), c^(j), {ĥ_(k) ^(j)}, h^(j)         ), where E( ) is an authenticated encryption. S_(k) is assumed         to be one of S_(i)'s direct children, ĥ_(k) ^(j) is calculated         as ĥ_(k) ^(j)=H(⊕_(l∈Øk)s_(l) ^(j)), where Ø_(k) is the set of         S_(k)'s descendants;     -   4) calculates         h^(j),c^(j)         _(σ) _(p) which is a signature generated using the signing key         inside TEE;     -   5) reveals         h^(j),c^(j)         _(σ) _(p) and C_(i) ^(j) to S_(p)

In other words in the preprocessing phase, S_(p)'s local trusted hardware pre-computes message authentication codes h^(j):=MAC(s^(j), c^(j)) for a set of counter values {c^(j)}, where s^(j) is a random secret. Then it splits s^(j) into shares {s₁ ^(j), s_(n) ^(j)} and calculates C_(i) ^(j):=E(

s_(i) ^(j), c^(j), h^(j)

) for each s_(i) ^(j). E( ) is an authenticated encryption. In one embodiment, E( ) uses the public encryption key of each S_(i), whose private decryption key is known only to the trusted hardware of the respective S_(i). In a second embodiment, E( ) uses a pair-wise symmetric key previously agreed between the trusted hardware modules of S_(p) and S_(i). Next, it reveals h^(j) and {C_(i) ^(j)} to S_(p), who sends in a further step C_(i) ^(j) to the corresponding S_(i).

In this embodiment an (f+1)-out-of-(f+1) secret sharing is used. Specifically, the secret s^(i) is split as s^(i)=s₁ ^(i)⊕ . . . ⊕s_(f+1) ^(i) and each replica obtains s_(j) ^(i), h^(i) is calculated as MAC(s^(i), c^(i)).

In a further embodiment (f+1)-out-of-n secret sharing may be used. Specifically, S_(p)'s trusted hardware first generates n random values x₁, . . . , x_(n), and for each x_(i) it computes

${y_{i} = \Pi_{j \neq i}}{\frac{x_{j}}{x_{j} - x_{i}}.}$

Then, for each counter value c^(i), it generates a polynomial f^(i)(x)=s^(i)+a₁ ^(i)x¹+ . . . +a_(f) ^(i)x^(f) for sharing a secret s^(i), and each replica obtains f^(i) (x_(i)) as the share s_(j) ^(i) and the S_(p) obtains MAC(f^(i)(x_(j))). h^(i) is calculated as MAC(s^(i), c^(i)) as well. To reconstruct the secret, S_(p) first checks whether MAC(f^(i)(x_(j))) is equal to the one it has received. Then it picks f+1 shares and calculates

s ^(i)=Σ_(i=1) ^(f+1)(x _(i))y _(i).

The primary node S_(p) then sends—as shown in FIG. 2—C_(i) ^(j) to each active replica S_(i). It can send these messages in batch for all counters.

After that the client C performs a request procedure according to the following:

C requests the execution of op by sending

REQUEST, op

_(σc) only to S_(p). If C receives no reply before a timeout, it broadcasts the REQUEST to all replicas.

The PN S_(p) then performs a prepare procedure 3) according to the following:

S_(p) multicasts or sends along a tree

PREPARE, M, v,

H(M), c_(j)

_(σ) _(p)

to all active S_(i)s.

H(M),c^(j)

_(σ) _(p) is returned by S_(p)'s local TEE, where c^(j) is the current counter value.

In the prepare phase for the j^(th) request, S_(p)'s trusted hardware signs a PREPARE message with the current counter value c^(j) inside, and gives it to S_(p), who multicasts it to all S_(i)s. In one embodiment, the signing is done by an authentic asymmetric signing key that is known only to the S_(p)'s trusted hardware. In a second embodiment, signing is done using a global symmetric key shared among the trusted hardware modules of all servers.

Then each active BN performs a commit procedure 4) and 5) according to the following:

Each active S_(i) gives

H(M),c^(j)

_(σ) _(p) and the corresponding C_(i) ^(j) to its local TEE, who verifies:

-   -   the validity of σ_(p);     -   the integrity of C_(i) ^(j);     -   whether the counter value inside C_(i) ^(j) is equal to c^(j);     -   whether c^(j) is sequential to the latest counter recorded by         itself.

If all are valid, the respective TEE records c^(j) as the latest counter value in its memory, decrypts C_(i) ^(j) and reveals the result to S_(i).

In a tree-like organizing structure of BN S_(i) first waits to receive a partial aggregate share ŝ_(k) ^(j) from each of its immediate children S_(k). Then it verifies if H(ŝ_(k) ^(j))=ĥ_(k) ^(j). If so, it calculates its own response ŝ_(i) ^(j)=s_(i) ^(j)⊕_(k∈Øi)ŝ_(k) ^(j) and sends to its parent according to 4) step in FIG. 3.

In FIG. 2 however no aggregation has to be performed s_(i) ^(j) is directly sent by S_(i) to the processing node 2.

In other words in the commit phase each replica S_(i) gives this PREPARE message together with the corresponding C_(i) ^(j) to its local trusted hardware, who verifies a) the validity of the signature in the PREPARE message, b) the integrity of C_(i) ^(j), c) whether the counter value in the PREPARE message matches the one in C_(i) ^(j), and d) whether c^(j) is sequential to the latest counter recorded by itself. If everything is alright, it reveals

s_(i) ^(j), c^(j), h^(j)

to S_(i), who then gives the share s_(i) ^(j) back to S_(p). S_(p) reconstructs the secret s^(j) if it receives at least a threshold number of replies. If the secret is correct (the MAC of the secret and the corresponding counter value meets the previous h^(j)), it e.g. multicasts the secret to each replica BN. From each replica's point of view, the secret represents a threshold number of COMMIT messages.

So after verifying the secret, each replica BN executes the request in the PREPARE message as shown in the following: After receiving the valid aggregate shares, S_(p) reconstructs s^(j) and verifies it with h^(j). If valid, S_(p) executes op and get the result res. Then it multicasts

COMMIT,s^(j),res,

H(res),c^(j+1)

_(σ) _(p)

to all active S_(i)s, where c^(j+1)=c^(j)+1 according to step 5) in FIG. 2. In FIG. 3 said commit message is transmitted along the tree to all active BN. Then in a further step upon receiving a valid s^(j), each active S_(i) executes op and get the result res. Then they perform the same procedure as the commit phase to open s^(j+1) and sent the result back to the PN S_(p) according to step 6) in FIGS. 2 and 3 either directly to S_(p) in FIG. 2 or along the tree in FIG. 3. S_(p) multicasts a reply message

REPLY,s^(j),

h^(j),c^(j)

_(σ) _(p)

H(M),c^(j)

_(σ) _(p) ,res,s^(j+1),

h^(j+1),c^(j+1)

_(σ) _(p) ,

H(res),c^(j+1)

_(σ) _(p)

to C as well as all other replicas in step 7)

To identify faulty replicas receiving and/or sending a PREPARE/COMMIT message, S_(i) starts a timer for each of its direct children upon receiving and/or sending a PREPARE/COMMIT. If it receives a valid share from S_(k) before the timer expires, it cancels the timer for S_(k). Otherwise, it sends a SUSPECT message (SUSPECT, S_(k)) to both S_(p) and its parent in case of a tree structure to signal the failure of S_(p). Moreover, if S_(i); receives a SUSPECT from its children, the message is forwarded to its parent, along the tree until reaches the root. Passing it along the tree allows us to cancel timers and reduce the number of SUSPECTs. If S_(p) receives multiple SUSPECTs along the same path, only the one closest to the leaf is handled.

On receiving a SUSPECT message, S_(p) sends a (NEW-TREE) message to all replicas, to replace the accused replica S_(k) with a randomly chosen passive replica and move the accuser S_(i) to a leaf position. From then on, S_(i) can no longer accuse any replicas. It either follows the specification of the protocol, or chooses not to participate in the agreement, in which case it will be moved to the passive replicas, so a faulty replica cannot constantly “accuse” others. In case of a star-like structure as shown e.g. in FIG. 2 no direct connection between BN is necessary. Therefore, a faulty BN has to be only recognized by the PN such that it will be regarded then as passive BN/replica.

If a replica BN receives a valid client request but receives no response from the primary node S_(p) after a timeout, it can suspect that the primary node S_(p) is faulty and initialize a view-change as follows

-   -   1) The suspecting replica sends a (PANIC) message to all other         replicas, who react by rebroadcasting the message to ensure that         all replicas are notified.     -   2) The new primary S_(p), is chosen deterministically as the         active replica with the lowest id apart from S_(p). S_(p), sends         HISTORY,O,         H(O),c         _(σ) _(p′)         to all replicas, where c is a counter value following the latest         counter value recorded by its local TEE, and O is the abort         history that includes:         -   REPLYs for the executed requests;         -   COMMITs for the committed requests;         -   PREPAREs for the prepared requests;         -   REQUESTS for the requests that receives no PREPAREs.     -   3) When S_(i) receives a HISTORY message from S_(p), it verifies         the history O first, and then sends         VIEW-CHANGE,H(O),         H(O),c         _(σ) _(i)         . When a replica has obtained a correct history and f matching         VIEW-CHANGE messages from different replicas, the history         becomes stable. In this case, the replica processes the abort         history, taking into account its local state. Having processed         the history, all non-faulty replicas are in a consistent state         and therefore able to safely switch to the new view.     -   4) After receiving f matching VIEW-CHANGE messages, S_(p),         broadcasts (NEW-VIEW,R,         H(R),(c+1))_(σ) _(p)         , where R is the set of f+1 new active replicas denominated by         S_(p),

In a further embodiment the present invention provides a method for byzantine fault tolerance data replication comprising the steps of

-   -   1) A client triggers the system by issuing a request.     -   2) One node among n nodes is elected as the primary in a view.         The other nodes are backup nodes.     -   3) During offline stage, the primary nodes' secure hardware         performs the following operations:         -   a. Generate a random secret value s^(j) for a counter c^(j)             that would be assigned to a REQUEST message m^(j) in the             future.         -   b. Compute the commitment of s^(j) and c^(j) as             h^(j)=MAC(s^(j),c^(j))         -   c. Generate n secret shares out of s^(j) as {s_(i) ^(j),             s_(n) ^(j)}         -   d. Calculate the authenticated encryption of each share that             can be only decrypted by the secure hardware of the             corresponding node S_(i) as C_(i) ^(j)=             c^(j),h^(j),E_(k) _(i) (s_(i) ^(j))         -   e. Send the encrypted share C_(i) ^(j) to each node S_(j)     -   4) During the online stage, after the primary node receives the         REQUEST message, it broadcasts a PREPARE message to the backup         nodes which is signed by its secure hardware along with the         monotonic counter value c^(j).     -   5) Each backup node verifies the PREPARE message to check the         signature and if the counter c^(j) is sequential to the last         seen counter from the primary. This check is done by the         backup's secure hardware.     -   6) If the PREPARE message is valid, the backup's secure hardware         updates the recorded primary counter to c^(j), retrieves the         corresponding encrypted share C_(i) ^(j), decrypt it and reveals         the share s^(j) to the primary node.     -   7) The primary collects t out of n shares and reconstruct the         secret s^(j), where t≤n including the primary's own share. If         t<n, the integrity of the each received share will be checked         before reconstruction.     -   8) With the reconstructed secret s^(j), the primary verifies if         it opens the commitment h^(j) that was generated during the         offline stage. If it is correct, the primary broadcasts the         opening (s^(j), c^(j)) to the backup nodes.     -   9) Each backup node verifies the received opening so against the         commitment h^(j) that was received during the offline stage. If         the opening is correct, the backup node may accept the request         message.

In a further embodiment of the present invention provides a method to aggregate commit/reply/update messages of the cheapBFT procedure so that the active replicas can get rid of the all-to-all broadcasts and the clients (as well as the passive replicas) only need to receive one instead of (f+1) REPLY (UPDATE) messages for a request. Here the primary node S_(p) uses a trusted counter and have S_(i)s record the latest counter value in their TEEs. As a result, all replicas maintain the same counter value.

In an embodiment the present invention further enables message aggregation without using any public key operations. By using a preprocessing phase, in which S_(p)'s local TEE generates a set of random secrets, and for each secret generates a commitment (hash). Then it splits each secrets into shares and gives each share to each active S_(i)'s TEE. It also reveals the commitment to all replicas. Later in the commit phase, each active S_(i) gets a share from its local TEE and sends it to S_(p), which represents its COMMIT. After gathering f shares, S_(p) reconstructs the secret and sends it to all S_(i)s, which represents f+1 COMMITs. The same applies for UPDATEs/REPLYs messages. However, since the secrets are generated in the preprocessing phase, it is impossible to bind a secret with a request. Instead, the S_(p)'s TEE binds the secret with a counter value in the preprocessing phase, and bind that counter value with a request in the prepare phase. Thus, a request is bond with a specific secret.

In an embodiment the present invention further enables to reduce the message complexity from O(n²) to O(n), the primary node S_(p) may organize the f+1 active replicas into a spanning tree rooted at itself, to distribute both communication and computation costs. The shares are sent in a bottom-up process and each intermediate node aggregates its children's shares together with its own, and finally S_(p) only needs to receive and aggregate a small constant number of shares. This improves the scalability. This efficiently makes use of the tree structure, since all f+1 active replicas are required to commit and execute the requests. So there will be no time delay when a faulty intermediate node makes its whole subtree “faulty”.

In an embodiment the present invention further enables a faulty replica being detected and replaced with a passive one according to the following: Any node can suspect its direct children and only its direct children by sending a signed suspicion message up the tree. A faulty node may be simply crash or send a wrong share. Its parent detects the crash failure by timeout and detects the Byzantine failure by verifying the share. S_(p) replaces the accused replica with a passive replica and puts the accuser in a leaf so that it cannot continue to accuse others. If S_(p) is faulty, all replicas will run a view-change operation to choose a new primary and a new set of active replicas.

The present invention, in particular some or all embodiments may be at least being based on or using at least part of MinBFT as disclosed in the non-patent literature of G. S. Veronese, M. Correia, A. N. Bessani, L. C. Lung, and P. Verissimo, “Efficient byzantine fault-tolerance,” IEEE Transactions on Computers, vol. 62, no. 1, pp. 16-30, January 2013, which is herein incorporated by reference.

The present invention, in particular some or all embodiments may be at least being based on or using at least part of Cheap BFT as disclosed in the non-patent literature of R. Kapitza, J. Behl, C. Cachin, T. Distler, S. Kuhnle, S. V. Mohammadi, W. Schroder-Preikschat, and K. Stengel, “Cheapbft: Resource-efficient byzantine fault tolerance,” in Proceedings of the 7^(th) ACM European Conference on Computer Systems, ser. EuroSys '12. New York, N.Y., USA: ACM, 2012, pp. 295-308, which is herein incorporated by reference.

The present invention, in particular some or all embodiments may be at least being based on or using at least part of a failure detection procedure as disclosed in the non-patent literature of S. Duan, H. Meling, S. Peisert, and H. Zhang, “Bchain: Byzantine replication with high throughput and embedded reconfiguration,” in Principles of Distributed Systems: 18th International Conference, OPODIS 2014, Cortina d'Ampezzo, Italy, December 16-19, 2014. Proceedings, M. K. Aguilera, L. Querzoni, and M. Shapiro, Eds. Cham: Springer International Publishing, 2014, pp. 91-106, which is herein incorporated by reference.

The present invention, in particular some or all embodiments may be at least being based on or using at least part of a practical byzantine fault tolerance procedures as disclosed in the non-patent-literature of M. Castro and B. Liskov, “Practical byzantine fault tolerance,” in Proceedings of the Third Symposium on Operating Systems Design and Implementation, ser. OSDI '99. Berkeley, Calif., USA: USENIX Association, 1999, pp. 173-186, available online http://dLacm.org/citation.cfm?id=296806.296824, which is herein incorporated by reference.

Further, at least one embodiment of the present invention enables or provides:

-   -   1. Secret sharing to minimize or completely near eliminate         public-key operations in a byzantine fault tolerance protocols         such that competition cause is reduced while having the same         communication demands.     -   2. Use of trusted computing technology.

In summary, at least one embodiment of the present invention enables a reduction in required servers from 3f+1 to 2f+1 and a number of communication rounds from 3 to 2. Further, at least one embodiment of the present invention does not rely on a symmetric cryptography relying on symmetric and lightweight cryptography enabling high throughput.

While the invention has been illustrated and described in detail in the drawings and foregoing description, such illustration and description are to be considered illustrative or exemplary and not restrictive. It will be understood that changes and modifications may be made by those of ordinary skill within the scope of the following claims. In particular, the present invention covers further embodiments with any combination of features from different embodiments described above and below.

The terms used in the claims should be construed to have the broadest reasonable interpretation consistent with the foregoing description. For example, the use of the article “a” or “the” in introducing an element should not be interpreted as being exclusive of a plurality of elements. Likewise, the recitation of “or” should be interpreted as being inclusive, such that the recitation of “A or B” is not exclusive of “A and B,” unless it is clear from the context or the foregoing description that only one of A and B is intended. Further, the recitation of “at least one of A, B and C” should be interpreted as one or more of a group of elements consisting of A, B and C, and should not be interpreted as requiring at least one of each of the listed elements A, B and C, regardless of whether A, B and C are related as categories or otherwise. Moreover, the recitation of “A, B and/or C” or “at least one of A, B or C” should be interpreted as including any singular entity from the listed elements, e.g., A, any subset from the listed elements, e.g., A and B, or the entire list of elements A, B and C. 

What is claimed is:
 1. A method for byzantine fault-tolerance replicating of data on a plurality of n servers, the n servers comprising one primary node (PN) and n−1 backup nodes (BN), wherein f servers may arbitrarily fail, and wherein all n servers have a trusted computing entity (TCE), the method comprising: performing, by the TCE of the PN, a preprocessing procedure comprising the steps of: computing at least one random secret value for at least one respective counter value of a unique, monotonic, sequential counter (UMSC) to be assigned with a request message for requesting an operation to be performed; computing a commitment for the random secret and the UMSC; splitting the at least one random secret into a plurality of shares; computing a server-specific authenticated encryption of each share of the at least one random secret, such that decryption can only be performed by the specified respective server, wherein during a later procedure the server-specific shares are used for verifying the request message; and providing the computed server-specific shares and the computed commitment to the respective servers.
 2. The method according to claim 1, wherein the performing the preprocessing procedure further comprises precomputing a plurality of message authentication codes, each respective message authentication code corresponding to a respective counter value of the USMC.
 3. The method according to claim 2, wherein each respective message authentication code is computed using a respective random secret.
 4. The method according to claim 3, wherein the splitting the at least one random secret into a plurality of shares comprises splitting each respective random secret into a plurality of shares.
 5. The method according to claim 4, wherein the computing a server-specific authenticated encryption of each share of the at least one random secret comprises computing a server-specific authenticated encryption of each share of each respective random secret.
 6. The method according to claim 5, wherein each server-specific encryption of a share of a respective random secret corresponds to a respective BN, and wherein each server-specific encryption of a respective random secret utilizes, for the encryption, a public key of the respective corresponding BN or a pairwise symmetric encryption between the PN and the respective corresponding BN.
 7. The method according to claim 1, further comprising organizing, by the PN, the active BN into a spanning tree comprising nodes and rooted at the PN, wherein intermediate nodes of the spanning tree of active BN are configured to aggregate shares within the tree.
 8. The method according to claim 7, wherein the directly connected BN are children of the BN and wherein the suspect message is also provided to a parent of the PN and wherein a suspect message is provided along the tree to the PN.
 9. The method according to claim 2, wherein splitting the at least one random secret into a plurality of shares comprises splitting each respective counter value of the USMC into a plurality of shares by utilizing an (f+1)-out-of-n secret sharing for each respective counter value of the USMC.
 10. The method according to claim 9, wherein for each respective counter value of the USMC, the TCE of the PN generates n random values and a polynomial, wherein each BN receives a share of a secret determined by evaluating the polynomial.
 11. The method according to claim 1, wherein a view number is included into messages for indicating a current view determining a certain server being PN and other servers being BN.
 12. The method according to claim 11, the method further comprising determining that the PN is faulty, performing a view change operation to select a new PN from the BN, and increasing the view number.
 13. The method according to claim 1, wherein upon valid verification of the reconstructed secret the PN performs a request and wherein a result of the performed request is transmitted to the BN together with an increased counter value.
 14. A system for byzantine fault-tolerance replicating of data on a plurality of servers by a client, the system comprising: n servers including one primary node (PN) and n−1 backup nodes (BN), wherein f servers may arbitrarily fail, and wherein all n servers have a trusted computing entity (TCE), wherein the TCE of the PN is adapted to perform the steps of: computing a random secret value for a unique, monotonic, sequential counter (UMSC), to be assigned with a request message for requesting an operation to be performed, computing a commitment for the random secret value and the UMSC, splitting the random secret value into a plurality of shares, computing a server-specific authenticated encryption of each share, such that decryption can only be performed by the specified respective server, wherein during a later procedure the server-specific shares are used for verifying the request message, and providing the computed server-specific shares and the computed commitment to the respective servers.
 15. A non-transitory computer readable medium storing a program which, when executed, causes a computer to execute a method for byzantine fault-tolerance replicating of data on a plurality of n servers, the n servers comprising one primary node (PN) and n−1 backup nodes (BN), wherein f servers may arbitrarily fail, and wherein all n servers having a trusted computing entity (TCE), the method comprising: performing, by the TCE of the PN, a preprocessing procedure comprising the steps of: computing a random secret value for a unique, monotonic, sequential counter (UMSC) to be assigned with a request message for requesting an operation to be performed, computing a commitment for the random secret value and the UMSC, splitting the random secret value into a plurality of shares, computing a server-specific authenticated encryption of each share, such that decryption can only be performed by the specified respective server, wherein during a later procedure the server-specific shares are used for verifying the request message, and providing the computed server-specific shares and the computed commitment to the respective servers. 